IPYNB Code/15_CNNCIFAR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Convolutional Neural Network\n",
    "**Sekilas tentang CNN**\n",
    "Convolutional Neural Network (CNN) adalah salah satu jenis neural network yang biasa digunakan pada data image. CNN bisa digunakan untuk mendeteksi dan mengenali object pada sebuah image. CNN adalah sebuah teknik yang terinspirasi dari cara mamalia — manusia, menghasilkan persepsi visual seperti contoh diatas. ([Sumber](https://medium.com/@16611110/apa-itu-convolutional-neural-network-836f70b193a4))\n",
    "\n",
    "<br>\n",
    "<div>\n",
    "<img src=\"../assets/typicalcnn.png\" width=\"400\"/>\n",
    "</div>\n",
    "\n",
    "[Sumber Gambar](https://www.quora.com/What-is-a-typical-convolutional-neural-network-CNN-architecture)\n",
    "<br>\n",
    "Pada umumnya, layer pada CNN akan tampak seperti gambar di atas:\n",
    "- Setelah input, akan dilajutkan dengan layer konvolusi yang berisi filter\n",
    "- Setelah layer konvolusi, umumnya akan dilanjutkan dengan pooling layer\n",
    "- Fully connected layer akan digunakan untuk menghasilkan output dan diletakkan pada bagian akhir\n",
    "\n",
    "<br>\n",
    "<div>\n",
    "<img src=\"../assets/convfilter.png\" width=\"400\"/>\n",
    "</div>\n",
    "\n",
    "[Sumber Gambar](https://www.researchgate.net/publication/329241581_Using_deep_learning_to_predict_soil_properties_from_regional_spectral_data/figures?lo=1)\n",
    "\n",
    "Filter akan dikonvolusikan terhadap input sehingga menghasilkan sebuah hasil yang ukurannya sama dengan besarnya filter yang digunakan\n",
    "\n",
    "**Max Pooling**\n",
    "Pooling merupakan pengurangan ukuran matriks dengan menggunakan operasi pooling. Pooling layer terdiri dari filter dengan ukuran dan stride tertentu yang berkonvolusi pada seluruh area feature map. Terdapa average pooling dan max pooling. Pada average pooling, nilai yang dihasilkan berdasarkan rata-rata, sementara pada max pooling, nilai yang dihasilkan adalah nilai maksimal. Lapisan Pooling yang dimasukkan diantara lapisan konvolusi secara berturut-turut dalam arsitektur model CNN dapat secara progresif mengurangi ukuran volume output pada Feature Map, sehingga mengurangi jumlah parameter dan perhitungan di jaringan, untuk mengendalikan Overfitting.([Sumber](https://medium.com/@mukhlishatunnada02/kegunaan-layar-pooling-pada-penerapan-deep-learning-menggunakan-convolutional-neural-network-140146078f28))\n",
    "\n",
    "Berikut ini adalah contoh gambar operasi max-pooling :\n",
    "<br>\n",
    "<div>\n",
    "<img src=\"../assets/pool_layer.png\" width=\"400\"/>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tahap Persiapan\n",
    "**Mengimpor Library**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Konfigurasi Device dan Hyperparameter**\n",
    "- Apabila GPU tersedia, gunakan GPU\n",
    "- Jika GPU tidak tersedia, gunakan CPU\n",
    "- Jumlah epoch, batch, dan learning rate di definisikan pada bagian ini"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "num_epochs = 4\n",
    "batch_size = 4\n",
    "learning_rate = 0.001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Konfigurasi Transform**\n",
    "- Pada percobaan ini, dataset CIFAR merupakan PILImage dengan rentang nilai pixel 0-1.\n",
    "- Transformasi dilakukan untuk tipe data menjadi tensor\n",
    "- Normalisasi dilakukan untuk mengubah nilai pixel menjadi 0-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Mengimpor Dataset**\n",
    "- Dataset tersedia melalui fungsi ```torchvision.datasets.CIFAR10``` dengan beberapa penjelasan argumen sebagai berikut\n",
    "    - ```root```: direktori dataset\n",
    "    - ```train```: boolean, jika True, maka dataset akan dijadikan training set\n",
    "    - ```transform```: transformasi yang dilakukan pada dataset\n",
    "    - ```download```: boolean, jika True, maka dataset akan diunduh dari internet\n",
    "- Dataset CIFAR10 ini merupakan dataset yang berisi 10 kategori dengan data training dan testing\n",
    "- ```trainloader``` digunakan untuk memuat data training pada variabel ```trainset```\n",
    "- ```testloader``` digunakan untuk memuat data testing pada variabel ```testset```\n",
    "- argumen ```batch_size``` digunakan untuk mengatur jumlah data yang dibaca per batch\n",
    "- argumen ```shuffle``` digunakan untuk mengatur apakah data akan diacak atau tidak\n",
    "- argumen ```num_workers``` digunakan untuk mengatur jumlah thread yang digunakan untuk membaca data\n",
    "    - Perlu diperhatikan bahwa jupyter notebook tidak mendukung multi-threading, jadi jika menggunakan multi-threading, maka harus menggunakan ```torch.multiprocessing.Pool```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "trainset = torchvision.datasets.CIFAR10(root='../data', train=True,\n",
    "                                        download=True, transform=transform)\n",
    "\n",
    "testset = torchvision.datasets.CIFAR10(root='../data', train=False,\n",
    "\n",
    "                                       download=True, transform=transform)\n",
    "\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
    "                                          shuffle=True, num_workers=0)\n",
    "\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
    "                                         shuffle=False, num_workers=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Menginisiasi Kelas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "classes = ('plane', 'car', 'bird', 'cat',\n",
    "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "test_images, test_labels = next(iter(trainloader))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tahap Mendesain Model\n",
    "Model yang akan digunakan adalah CNN dengan struktur seperti gambar berikut:\n",
    "\n",
    "<br>\n",
    "<div>\n",
    "<img src=\"../assets/cnnmodels.jpeg\" width=\"700\"/>\n",
    "</div>\n",
    "\n",
    "([Sumber Gambar: mathworks.com](https://www.mathworks.com/discovery/convolutional-neural-network-matlab.html))\n",
    "\n",
    "- Arsitektur ini memiliki dua komponen utama yaitu feature learning dan classifier\n",
    "- Feature learning akan mempelajari fitur gambar dan menghasilkan output yang dapat digunakan untuk classifier\n",
    "- Classifier yang nantinya akan menentukan gambar input masuk ke kelas yang mana\n",
    "\n",
    "**Komponen Layer**\n",
    "- Layer 1: Convolutional Layer 2 Dimensi dengan ukuran input 3 (RGB channel), ukuran output adalah 6, dan ukuran kernel adalah 5\n",
    "- Layer 2: Max Pooling Layer 2 Dimensi dengan ukuran kernel 2 dan stride 2\n",
    "- Layer 3: Convolutional Layer 2 Dimensi dengan ukuran channel 6, ukuran output adalah 16, dan ukuran kernel adalah 5. Ukuran input adalah output dari layer 1\n",
    "- Layer 4: Max Pooling Layer 2 Dimensi dengan ukuran kernel 2 dan stride 2 (sama seperti layer 2)\n",
    "- Layer 5: Image diflatten dan dimasukkan ke Fully Connected Layer dengan ukuran input 16 * 5 * 5, ukuran output adalah 120\n",
    "- Layer 6: Fully connected layer dengan ukuran input 120, ukuran output adalah 84\n",
    "- Layer 7: Fully connected layer dengan ukuran input 84, ukuran output adalah 10 (jumlah kelas)\n",
    "\n",
    "**Perubahan shape image**\n",
    "- Pada awalnya, gambar input adalah 3 dimensi (RGB) dengan ukuran 32x32 piksel\n",
    "- Setelah melewati layer 1, gambar akan berubah menjadi 6 dimensi (RGB) dengan ukuran 28x28 piksel. Mengapa menjadi 28 piksel?\n",
    "- Formula Conv Layer: $$\\frac{(W - F + 2*P)}{S} + 1$$\n",
    "- Width (W) awal adalah 32, dikurang dengan ukuran kernel 5 (F), ditambah 0 (tanpa padding), dan dibagi dengan stride 1 (S) dan ditambah 1\n",
    "- $$\\frac{(32 - 5 + 2*0)}{1} + 1 = 28$$\n",
    "- Setelah melewati layer 2, gambar akan berubah menjadi 16 dimensi (RGB) dengan ukuran 14x14 piksel. Mengapa menjadi 14 piksel?\n",
    "- Karena layer setelahnya adalah pooling layer dengan ukuran 2x2 dan stride 2 sehingga ukuran gambar dikurangi menjadi setengahnya\n",
    "- Setelah melewati layer 3, gambar akan berubah menjadi 16 channel dengan ukuran 10x10 piksel.\n",
    "- Dan setelah melewati layer ke 4, gambar akan memiliki ukuran 16 channel dengan ukuran 5x5 piksel. Karena layer setelahnya adalah pooling layer dengan ukuran 2x2 dan stride 2 sehingga ukuran gambar dikurangi menjadi setengahnya\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "class ConvNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvNet, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = self.pool(x)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = self.pool(x)\n",
    "        x = x.view(-1, 16 * 5 * 5)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "model = ConvNet().to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Mendefinisikan fungsi loss dan optimizer**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Ilustrasi proses convolution layer**\n",
    "\n",
    "***Proses ini tidak dibutuhkan untuk melakukan training. Hanya gambaran bagi anda untuk mengetahui proses convolution layer***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "testconv1 = nn.Conv2d(3, 6, 5)\n",
    "testpool = nn.MaxPool2d(2, 2)\n",
    "testconv2 = nn.Conv2d(6, 16, 5)\n",
    "testfc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "testfc2 = nn.Linear(120, 84)\n",
    "testfc3 = nn.Linear(84, 10)\n",
    "\n",
    "plt.imshow(test_images[0].permute(1, 2, 0))\n",
    "plt.title(\"Original Image | Kelas: {}\".format(classes[test_labels[0]]))\n",
    "plt.show()\n",
    "\n",
    "test_images = testconv1(test_images)\n",
    "ungrad_test_images = test_images.cpu().detach().numpy()\n",
    "print(ungrad_test_images.shape)\n",
    "\n",
    "for i in range(6):\n",
    "    plt.subplot(2, 3, i+1)\n",
    "    plt.tight_layout(h_pad=3)\n",
    "    plt.imshow(ungrad_test_images[0, i, :, :])\n",
    "    plt.title(\"Channel {}\".format(i+1))\n",
    "    plt.suptitle(\"Setelah Conv1\")\n",
    "plt.show()\n",
    "\n",
    "test_images = testpool(test_images)\n",
    "ungrad_test_images = test_images.cpu().detach().numpy()\n",
    "print(ungrad_test_images.shape)\n",
    "\n",
    "for i in range(6):\n",
    "    plt.subplot(2, 3, i+1)\n",
    "    plt.tight_layout(h_pad=3)\n",
    "    plt.imshow(ungrad_test_images[0, i, :, :])\n",
    "    plt.title(\"Channel {}\".format(i+1))\n",
    "    plt.suptitle(\"Setelah Pool1\")\n",
    "plt.show()\n",
    "\n",
    "test_images = testconv2(test_images)\n",
    "ungrad_test_images = test_images.cpu().detach().numpy()\n",
    "print(ungrad_test_images.shape)\n",
    "\n",
    "for i in range(3):\n",
    "    plt.subplot(2, 3, i+1)\n",
    "    plt.tight_layout(h_pad=3)\n",
    "    plt.imshow(ungrad_test_images[0, i, :, :])\n",
    "    plt.title(\"Channel {}\".format(i+1))\n",
    "    plt.suptitle(\"Setelah Conv2\")\n",
    "plt.show()\n",
    "\n",
    "test_images = testpool(test_images)\n",
    "ungrad_test_images = test_images.cpu().detach().numpy()\n",
    "print(ungrad_test_images.shape)\n",
    "\n",
    "for i in range(3):\n",
    "    plt.subplot(2, 3, i+1)\n",
    "    plt.tight_layout(h_pad=3)\n",
    "    plt.imshow(ungrad_test_images[0, i, :, :])\n",
    "    plt.title(\"Channel {}\".format(i+1))\n",
    "    plt.suptitle(\"Setelah Pool2\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Tahap Training dan Testing\n",
    "**Training Loop**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "n_total_steps = len(trainloader)\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    for i, (images, labels) in enumerate(trainloader):\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        outputs = model(images)\n",
    "        loss = criterion(outputs, labels)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if (i+1) % 100 == 0:\n",
    "            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
    "                   .format(epoch+1, num_epochs, i+1, n_total_steps, loss.item()))\n",
    "\n",
    "print('Training Selesai')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "**Testing Loop**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    n_correct = 0\n",
    "    n_samples = 0\n",
    "    n_class_correct = [0 for i in range(10)]\n",
    "    n_class_samples = [0 for i in range(10)]\n",
    "\n",
    "    for images, labels in testloader:\n",
    "        images = images.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        n_samples += labels.size(0)\n",
    "        n_correct += (predicted == labels).sum().item()\n",
    "\n",
    "        for i in range(batch_size):\n",
    "            label = labels[i]\n",
    "            pred = predicted[i]\n",
    "            if label == pred:\n",
    "                n_class_correct[label] += 1\n",
    "            n_class_samples[label] += 1\n",
    "\n",
    "    print(f'Accuracy: {n_correct/n_samples*100:.4f}%')\n",
    "\n",
    "    for i in range(10):\n",
    "        print(f'Akurasi kelas- {classes[i]}: {n_class_correct[i]/n_class_samples[i]*100:.4f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Menyimpan Parameter dari Model\n",
    "Lihat [disini](https://pytorch.org/docs/stable/generated/torch.save.html) dokumentasi terkait penyimpanan objek menggunakan torch\n",
    "\n",
    "Penjelasan Kode:\n",
    "- perintah ```torch.save``` digunakan untuk menyimpan objek (termasuk parameter model) menjadi sebuah file\n",
    "- argumen pertama adalah objek yang akan disimpan, dalam hal ini adalah parameter model\n",
    "- argumen kedua adalah nama file yang akan disimpan\n",
    "- dalam PyTorch pada umumnya kita menggunakan ekstensi file `.pt` atau `.pth` untuk menyimpan parameter model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), '../lainnya/convnet.pth') # silahkan sesuaikan path dengan folder anda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Memuat Parameter Model**\n",
    "Untuk memuat kembali parameter dari model yang telah disimpan, langkah pertama haruslah mengcopy dahulu modelnya sebelum memasukkan parameter tersimpan.\n",
    "\n",
    "Penjelasan:\n",
    "- perintah ```torch.load``` digunakan untuk memuat objek (termasuk parameter model) dari sebuah file\n",
    "- ```model2.eval()``` menyatakan bahwa model akan berperilaku dalam mode evaluasi. Beberapa komponen ataupun layer dalam model akan menyesuaikan perilakunya ketika dalam model evaluasi seperti mematikan Dropout. Lihat pembahasan lengkap [di sini](https://stackoverflow.com/questions/60018578/what-does-model-eval-do-in-pytorch) atau tonton video penjelasannya [di sini](https://www.youtube.com/watch?v=GzjRE3MUx6Q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model2 = ConvNet().to(device)\n",
    "model2.load_state_dict(torch.load('../lainnya/convnet.pth'))\n",
    "\n",
    "# model siap untuk tahap testing (mode evaluasi)\n",
    "with torch.no_grad():\n",
    "    model2.eval()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "81b9ccaf5ef21c8a6faa6d42f6e42fcf9eafd7625a2befdd601079168fccee32"
  },
  "kernelspec": {
   "display_name": "Python 3.8.13 ('py38')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}